package com.tests;

import java.util.*;

import com.metier.*;
import com.persistance.AccesData;

import static org.junit.Assert.*;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * Classe de test des classes DAO
 * 
 * @author b0dian
 * @version 1.0
 *
 */
public class AccesDataTest {
	List<TypeCharge> listeCharge;
	List<Station> listeStation;
	List<Borne> listeBorne;
	TypeCharge t;
	Station s;
	Borne b;

	@Before
	public void setUp() throws Exception {

	}

	@After
	public void tearDown() throws Exception {

	}

	/**
	 * Va recuperer tout les Types Charges de la base et tester en brut
	 * l'exactitude des informations fournies
	 */
	@Test
	public void testGetListeTypeCharge() {
		// recuperation des types charges dans la base
		listeCharge = AccesData.getTypesCharges();
		// base contient 3 types charges
		// 3 utilises
		assertNotNull(listeCharge);
		assertEquals(listeCharge.size(), 3);
		// test des valeurs des proprietes recuperees
		assertEquals(listeCharge.get(0).getCodeTypeCharge(), 1);
		assertEquals(listeCharge.get(0).getLibelleTypeCharge(), "normale");
		assertEquals(listeCharge.get(0).getPuissance(), 3);
		assertEquals(listeCharge.get(1).getCodeTypeCharge(), 2);
		assertEquals(listeCharge.get(1).getLibelleTypeCharge(), "semi-rapide");
		assertEquals(listeCharge.get(1).getPuissance(), 24);
		assertEquals(listeCharge.get(2).getCodeTypeCharge(), 3);
		assertEquals(listeCharge.get(2).getLibelleTypeCharge(),
				"recharge rapide");
		assertEquals(listeCharge.get(2).getPuissance(), 50);
	}

	/**
	 * Va recuperer toutes les Stations de la base et tester en brut
	 * l'exactitude des informations fournies
	 */
	@Test
	public void testGetListeStation() {

		// recuperation des stations dans la base
		listeStation = AccesData.getStations();
		// etat initial 3 elements dont 2 stations uniquement avec bornes(1 et
		// 2)
		assertEquals(listeStation.size(), 3);
		// test des informations de la station 1 qui a 2 bornes
		s = listeStation.get(0);
		assertEquals(s.getIdStation(), 1);
		assertEquals(s.getLibelleEmplacement(), "Gare MontParnasse");
		listeBorne = s.getLesBornes();
		assertEquals(listeBorne.size(), 2);
		// test des informations de la station 3 en position 3 dans la
		// collection qui a 0 borne
		s = listeStation.get(2);
		assertEquals(s.getIdStation(), 3);
		assertEquals(s.getLibelleEmplacement(), "Gare de l'Est");
		listeBorne = s.getLesBornes();
		assertEquals(listeBorne.size(), 0);
	}

	/**
	 * Va recuperer toutes les Bornes de la base et tester en brut l'exactitude
	 * des informations fournies
	 */
	@Test
	public void testGetListeBorne() {
		// recuperation liste de bornes
		// 5 dans la base de donnees
		listeBorne = AccesData.getBornes();
		assertEquals(listeBorne.size(), 5);
		// test des donnees de la premiere borne de la collection id 1
		b = listeBorne.get(0);
		assertEquals(b.getIdBorne(), 1);
		assertEquals(b.getEtat(), "ES");
		assertEquals(b.getType().getCodeTypeCharge(), 1);
		assertEquals(b.getType().getLibelleTypeCharge(), "normale");
		assertEquals(b.getType().getPuissance(), 3);
	}

	/**
	 * Va recuperer toutes les Bornes correspondant a une station dans la base
	 * et tester en brut l'exactitude des informations fournies
	 */
	@Test
	public void testGetListeBorneStation() {
		// station qui existe
		listeBorne = AccesData.getBorneByIdStation(1);
		assertEquals(listeBorne.size(), 2);
		b = listeBorne.get(1);
		assertEquals(b.getIdBorne(), 2);
		assertEquals(b.getEtat(), "ES");
		assertEquals(b.getType().getCodeTypeCharge(), 2);
		assertEquals(b.getType().getLibelleTypeCharge(), "semi-rapide");
		assertEquals(b.getType().getPuissance(), 24);
		// station qui n'existe pas, ramene 0 bornes
		listeBorne = AccesData.getBorneByIdStation(4);
		assertEquals(listeBorne.size(), 0);

	}

	/**
	 * Verifier l'existance de type charge dont correspondant a un id en
	 * verifiant que ce qui est retourne est correct
	 */
	@Test
	public void testGetTypeCharge() {

		// test sur Type charge existant code type 1
		t = AccesData.getTypeCharge(1);
		assertNotNull(t);
		assertEquals(t.getCodeTypeCharge(), 1);
		assertEquals(t.getLibelleTypeCharge(), "normale");
		assertEquals(t.getPuissance(), 3);
		// test sur type charge qui n'existe pas code type 5
		t = AccesData.getTypeCharge(5);
		assertEquals(t, null);

	}

	/**
	 * Va aller chercher une station existante dans la base et verifier
	 * l'exactitude des infos recupere en brut
	 */
	@Test
	public void testGetStation() {
		// station qui existe
		s = AccesData.getStation(1);
		assertNotNull(s);
		assertEquals(s.getLesBornes().size(), 2);
		// station qui n'existe pas
		s = AccesData.getStation(100);
		assertNull(s);
	}

	/**
	 * Va aller recuperer une borne existante dans la base et verifie que la
	 * borne retourner correspond a celle demande
	 */
	@Test
	public void testGetBorne() {
		// borne qui existe
		b = AccesData.getBorne(1);
		assertNotNull(b);
		assertEquals(b.getEtat(), "ES");
		assertEquals(b.getDateMiseEnService(), "12/12/2010");
		assertEquals(b.getIdBorne(), 1);
		assertEquals(b.getType().getCodeTypeCharge(), 1);
		// borne qui n'existe pas
		b = AccesData.getBorne(500);
		assertNull(b);
	}

	/**
	 * Ici il est necessaire de tester deux methodes en mème temps l'ajout suivi
	 * directement de la suppression pour ne pas fausser les resultats des tests
	 * precedents
	 */
	@Test
	public void testAddDeleteTypeCharge() {
		TypeCharge t = new TypeCharge("tres rapide", 100);
		assertTrue(AccesData.createTypeCharge(t));
		// test suppression typecharge utilisee
		t = AccesData.getTypeCharge(2);
		assertFalse(AccesData.deleteTypeCharge(t));
		// suppresssion du dernier type charge insere pour remettre la base en
		// etat initial
		List<TypeCharge> listeTypeCharge = AccesData.getTypesCharges();
		// ajout en dernier, donc on efface le dernier ajoute en size() -1
		assertTrue(AccesData.deleteTypeCharge(listeTypeCharge.get(listeTypeCharge.size() - 1)));
		}

	/**
	 * ici nous allons verifier que la modification a bien effectue puis
	 * remettre la base a son etat initial immediatement derrière pour ne pas
	 * fosser les autres methodes
	 */
	@Test
	public void testUpdateTypeCharge() {
		// on recupere un typeCharge existant
		TypeCharge t = AccesData.getTypeCharge(1);
		// on sauvegarde la valeur des proprietes
		String ancLibelle = t.getLibelleTypeCharge();
		int ancPuissance = t.getPuissance();
		// on modifie les proprietes de l'objet
		t.setLibelleTypeCharge("megakg");
		t.setPuissance(450);
		// on effectue la mise e jour dans la base
		assertTrue(AccesData.updateTypeCharge(t));
		// on recupere l'etat l'objet de la base
		t = AccesData.getTypeCharge(1);
		// on teste la valeur des proprietes modifiees
		assertEquals(t.getLibelleTypeCharge(), "megakg");
		assertEquals(t.getPuissance(), 450);
		// on remet e l'etat initial
		t.setLibelleTypeCharge(ancLibelle);
		t.setPuissance(ancPuissance);
		assertTrue(AccesData.updateTypeCharge(t));
	}

	/**
	 * Ici il est necessaire de tester deux methodes en mème temps l'ajout suivi
	 * directement de la suppression pour ne pas fausser les resultats des tests
	 * precedents
	 */
	@Test
	public void testAddDeleteBorne() {
		// on ajoute une nouvelle borne
		TypeCharge t = AccesData.getTypeCharge(1);
		Borne b = new Borne("12/12/2013", 1, t);
		assertTrue(AccesData.createBorne(b));
		// onrecupere la liste des bornes , dernier element est le nouvel insere
		List<Borne> listeBorne = AccesData.getBornes();
		// onsupprime le dernier
		AccesData.deleteBorne(listeBorne.get(listeBorne.size() - 1));
	}

	/**
	 * ici nous allons verifier que la modification a bien effectue puis
	 * remettre la base a son etat initial immediatement derrière pour ne pas
	 * fosser les autres methodes
	 */
	@Test
	public void testUpdateBorne() {
		// recuperation borne 1
		Borne b = AccesData.getBorne(1);
		assertEquals(b.getIdStation(), 1);
		assertEquals(b.getDateMiseEnService(), "12/12/2010");
		assertEquals(b.getType().getCodeTypeCharge(), 1);
		// modification des donnees idStation et typeCharge
		b.setIdStation(2);
		b.setType(AccesData.getTypeCharge(3));
		// // mise e jour
		assertTrue(AccesData.updateBorne(b));
		b.setIdStation(1);
		b.setType(AccesData.getTypeCharge(1));
		// // remise e l'etat initial
		assertTrue(AccesData.updateBorne(b));
	}

	/**
	 * Ici il est necessaire de tester deux methodes en mème temps l'ajout suivi
	 * directement de la suppression pour ne pas fausser les resultats des tests
	 * precedents
	 */
	@Test
	public void testAddDeleteStation() {
		// ajout station
		Station s = new Station("tests station");
		assertTrue(AccesData.createStation(s));
		// recuperation liste des stations , nouvelle station en position 0 dans
		// la liste
		List<Station> listeStation = AccesData.getStations();
		// suppressison de la station en premiere position dans la liste

		// remise en l'etat initial avant fin methode
		assertTrue(AccesData.deleteStation(listeStation.get(listeStation.size() - 1)));
		// suppression station liee impossible
		s = AccesData.getStation(2);
		assertFalse(AccesData.deleteStation(s));
	}

	/**
	 * ici nous allons verifier que la modification a bien effectue puis
	 * remettre la base a son etat initial immediatement derrière pour ne pas
	 * fosser les autres methodes
	 */
	@Test
	public void testUpdateStation() {
		// recuperation station 1
		Station s = AccesData.getStation(1);
		// sauvegarde ancien libelle pour retablissement situation en fin de
		// methode
		String ancValeur = s.getLibelleEmplacement();
		// modification libelle
		String nouvelleValeur = "gare test";
		s.setLibelleEmplacement(nouvelleValeur);
		assertTrue(AccesData.updateStation(s));
		// remise e l'etat initial
		s.setLibelleEmplacement(ancValeur);
		assertTrue(AccesData.updateStation(s));
		// acces en lecture pour rafraichissement
		s = AccesData.getStation(1);
	}
}
